home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk10.zip / REXP1.C < prev    next >
C/C++ Source or Header  |  1991-10-05  |  4KB  |  188 lines
  1.  
  2. /********************************************
  3. rexp1.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13. /*$Log:    rexp1.c,v $
  14.  * Revision 3.2  91/08/13  09:10:11  brennan
  15.  * VERSION .9994
  16.  * 
  17.  * Revision 3.1  91/06/07  10:33:22  brennan
  18.  * VERSION 0.995
  19.  * 
  20. */
  21.  
  22. /*  re machine  operations  */
  23.  
  24. #include  "rexp.h"
  25.  
  26. static MACHINE *PROTO( new_TWO , (int) ) ;
  27.  
  28.  
  29. static  MACHINE  *new_TWO(type)
  30.   int type ;
  31. { 
  32.   static  MACHINE  x ;
  33.  
  34.   x.start = (STATE *) RE_malloc(2*STATESZ) ;
  35.   x.stop = x.start + 1 ;
  36.   x.start->type = type ;
  37.   x.stop->type = M_ACCEPT ;
  38.   return &x ;
  39. } ;
  40.  
  41.  
  42. /*  build a machine that recognizes any  */
  43. MACHINE  RE_any()
  44. { return  * new_TWO(M_ANY) ; }
  45.  
  46. /*  build a machine that recognizes the start of string  */
  47. MACHINE  RE_start()
  48. { return  * new_TWO(M_START) ; }
  49.  
  50. MACHINE  RE_end()
  51. { return  * new_TWO(M_END) ; }
  52.  
  53. /*  build a machine that recognizes a class  */
  54. MACHINE  RE_class( bvp )
  55.   BV *bvp  ;
  56. { register MACHINE *p = new_TWO(M_CLASS) ;
  57.  
  58.   p->start->data.bvp = bvp ;
  59.   return *p ;
  60. }
  61.  
  62.  
  63. MACHINE  RE_u()
  64. { return  *new_TWO(M_U) ; }
  65.  
  66. MACHINE  RE_str( str, len)
  67.   char *str ;
  68.   unsigned len ;
  69. { register MACHINE *p = new_TWO(M_STR) ;
  70.  
  71.   p->start->len = len ;
  72.   p->start->data.str = str ;
  73.   return *p ;
  74. }
  75.  
  76. /*  replace m and n by a machine that recognizes  mn   */
  77. void  RE_cat( mp, np)
  78.   MACHINE  *mp, *np ;
  79. { unsigned sz1, sz2, sz ;
  80.  
  81.   sz1 = mp->stop - mp->start  ;
  82.   sz2 = np->stop - np->start + 1 ;
  83.   sz  = sz1 + sz2 ;
  84.  
  85.   mp->start = (STATE *) RE_realloc( mp->start, sz * STATESZ ) ;
  86.   mp->stop = mp->start + (sz - 1) ;
  87.   (void)  memcpy( mp->start + sz1, np->start, SIZE_T(sz2 * STATESZ) ) ;
  88.   free( np->start ) ;
  89. }
  90.  
  91.  /*  replace m by a machine that recognizes m|n  */
  92.  
  93. void  RE_or( mp, np)
  94.   MACHINE  *mp, *np ;
  95. { register STATE *p ;
  96.   unsigned szm, szn ;
  97.  
  98.   szm = mp->stop - mp->start + 1 ;
  99.   szn = np->stop - np->start + 1 ;
  100.  
  101.   p = (STATE *) RE_malloc( (szm+szn+1) * STATESZ ) ;
  102.   (void) memcpy( p+1, mp->start, SIZE_T(szm * STATESZ) ) ;
  103.   free( mp->start) ;
  104.   mp->start = p ;
  105.   (mp->stop  = p + szm + szn) -> type = M_ACCEPT ;
  106.   p->type = M_2JA ;
  107.   p->data.jump = szm+1 ;
  108.   (void) memcpy( p + szm + 1 , np->start, SIZE_T(szn * STATESZ)) ;
  109.   free( np->start ) ;
  110.   (p += szm)->type = M_1J ;
  111.   p->data.jump = szn ;
  112. }
  113.  
  114. /*  UNARY  OPERATIONS     */
  115.  
  116. /*  replace m by m*   */
  117.  
  118. void  RE_close( mp )
  119.   MACHINE  *mp ;
  120. { register STATE *p ;
  121.   unsigned sz ;
  122.  
  123.   sz = mp->stop - mp->start + 1 ;
  124.   p = (STATE *) RE_malloc( (sz+2) * STATESZ ) ;
  125.   (void) memcpy( p+1, mp->start, SIZE_T(sz * STATESZ)) ;
  126.   free( mp->start ) ;
  127.   mp->start = p ;
  128.   mp->stop  = p + (sz+1) ;
  129.   p->type = M_2JA ;
  130.   p->data.jump = sz + 1 ;
  131.   (p += sz) -> type = M_2JB ;
  132.   p->data.jump = -(sz-1) ;
  133.   (p+1)->type = M_ACCEPT ;
  134. }
  135.  
  136. /*  replace m  by  m+  (positive closure)   */
  137.  
  138. void  RE_poscl( mp )
  139.   MACHINE  *mp ;
  140. { register STATE *p ;
  141.   unsigned  sz ;
  142.  
  143.   sz = mp->stop - mp->start + 1 ;
  144.   mp->start = p = (STATE *) RE_realloc(mp->start ,  (sz+1) * STATESZ ) ;
  145.   mp->stop  = p + sz ;
  146.   p +=  --sz ;
  147.   p->type = M_2JB ;
  148.   p->data.jump = -sz ;
  149.   (p+1)->type = M_ACCEPT ;
  150. }
  151.  
  152. /* replace  m  by  m? (zero or one)  */
  153.  
  154. void  RE_01( mp )
  155.   MACHINE  *mp ;
  156. { unsigned  sz ;
  157.   register  STATE *p ;
  158.  
  159.   sz = mp->stop - mp->start + 1 ;
  160.   p = (STATE *) RE_malloc( (sz+1) * STATESZ ) ;
  161.   (void) memcpy( p+1, mp->start, SIZE_T(sz * STATESZ)) ;
  162.   free( mp->start ) ;
  163.   mp->start = p ;
  164.   mp->stop = p + sz ;
  165.   p->type = M_2JB ;
  166.   p->data.jump = sz ;
  167. }
  168.  
  169. /*===================================
  170. MEMORY  ALLOCATION
  171.  *==============================*/
  172.  
  173.  
  174. VOID *RE_malloc( sz ) 
  175.   unsigned sz ;
  176. { register VOID *p ;
  177.  
  178.   if ( ! ( p = malloc(SIZE_T(sz)) ) )  RE_error_trap(MEMORY_FAILURE) ;
  179.   return p ;
  180. }
  181.  
  182. VOID *RE_realloc( p, sz)
  183.   register VOID *p ; unsigned sz ;
  184. { if ( ! ( p = realloc( p, SIZE_T(sz)) ) )  RE_error_trap(MEMORY_FAILURE) ;
  185.   return p ;
  186. }
  187.  
  188.